home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / InitData.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  23KB  |  1,039 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *    RSysInitData.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    int ChooseNewFile ( char *oldfile , char *header );
  12.    *    RSYS_ValidMemoryNode *CheckNode ( ULONG memoryptr );
  13.    *    void BuildAllDataEntries ( void );
  14.    *    void BuildHardwareList ( void );
  15.    *    void BuildHelpList ( void );
  16.    *    void BuildLibOffsetList ( void );
  17.    *    void BuildValidAddressList ( void );
  18.    *    void FreeAmigaGuideContextMemory ( void );
  19.    *    void FreeHardwareData ( void );
  20.    *    void FreeLibOffData ( void );
  21.    *    void FreeValidAddressList ( void );
  22.    *    void SaveConfig ( void );
  23.    *
  24.    *      --- Lokale  Routinen ---
  25.    *
  26.    *    static int AllocLineBuffer ( void );
  27.    *    static int MarkAddress ( ULONG start , ULONG length , char type , char *comment );
  28.    *    static int ReadCompanies ( BPTR hfile );
  29.    *    static int ReadContextFile ( UBYTE *filename );
  30.    *    static int ReadHardwareData ( BPTR hfile );
  31.    *    static int ReadLibOff ( BPTR lofile );
  32.    *    static int SplitFunction ( char *data , RSYS_FUNCTION *func , LIBRARY *lib );
  33.    *    static STRPTR CheckHardwareEntry ( STRPTR buffer , int *type );
  34.    *    static STRPTR CheckLibOffEntry ( STRPTR buffer , int *type );
  35.    *    static UBYTE *myFGets ( BPTR file , STRPTR buffer , long size );
  36.    *    static void FreeLineBuffer ( void );
  37.    *
  38.    * Bemerkungen:
  39.    *    Enthält die Routinen zur Initialisierung der externen Daten.
  40.    *
  41.    * Erstellungsdatum:
  42.    *    20-Jul-93    Rolf Böhme
  43.    *
  44.    * Änderungen:
  45.    *    20-Jul-93    Rolf Böhme    Erstellung
  46.    *
  47.    ***************************************************************************
  48.  */
  49.  
  50. #include "RSys.h"
  51. #include "protos.h"
  52.  
  53.  
  54. /*#include "I.c" */
  55.  
  56. static REMEMBER *HWKey = NULL;
  57. static REMEMBER *LOKey = NULL;
  58. static REMEMBER *VMKey = NULL;
  59. static REMEMBER *ContextKey = NULL;
  60.  
  61.  
  62. static char *datatype[] =
  63. {
  64.   "END", "MANUFACTURER", "PRODUCT", "TYPE", "NAME", "COMPANY", "UNKNOWN"
  65. };
  66.  
  67. static char *libofftype[] =
  68. {
  69.   "END", "LIBNAME", "TYP", "BASE", "RSYS_FUNCTION"
  70. };
  71.  
  72.  
  73. static UBYTE *filebuffer;
  74. #define MAXLINE 256
  75.  
  76. static int
  77. AllocLineBuffer (void)
  78. {
  79.   if (filebuffer = MyAllocVec ((MAXLINE + 1) * sizeof (UBYTE), MEMF_CLEAR, NO_KILL))
  80.     return TRUE;
  81.  
  82.   ErrorHandle ("No file buffer for reading", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  83.  
  84.   return FALSE;
  85. }
  86.  
  87. static void
  88. FreeLineBuffer (void)
  89. {
  90.   MyFreeVec (filebuffer);
  91.  
  92.   return;
  93. }
  94.  
  95. int
  96. ChooseNewFile (char *oldfile, char *header)
  97. {
  98.   char dir[MAXFULLNAME], file[MAXFULLNAME];
  99. /*
  100.    char *dir = NULL,
  101.    *file = NULL;
  102.  */
  103.   int ok = TRUE;
  104.  
  105.   if (!SysWnd)
  106.     return ok;
  107.  
  108. /*
  109.    if ((dir = MyAllocVec(MAXFULLNAME, MEMF_CLEAR, NO_KILL)) &&
  110.    (file = MyAllocVec(MAXFULLNAME, MEMF_CLEAR, NO_KILL)))
  111.    {
  112.  */
  113.   strncpy (file, (char *) FilePart ((STRPTR) oldfile), MAXFULLNAME);
  114.   strncpy (dir, oldfile, (int) ((ULONG) PathPart ((STRPTR) oldfile) - (ULONG) oldfile));
  115.  
  116.   if (GetFile (SysWnd, dir, file, "#?", header, "Load"))
  117.     strncpy (oldfile, _fullpath, MAXFULLNAME);
  118.   else
  119.     ok = FALSE;
  120. /*
  121.    }
  122.    else
  123.    {
  124.    ok = FALSE;
  125.    ErrorHandle(oldfile, MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  126.    }
  127.  
  128.    MyFreeVec(file);
  129.    MyFreeVec(dir);
  130.  */
  131.  
  132.   return ok;
  133. }
  134.  
  135.  
  136. void
  137. FreeHardwareData (void)
  138. {
  139.   FreeRemember (HWKEY, TRUE);
  140.   return;
  141. }
  142.  
  143. static UBYTE *
  144. myFGets (BPTR file, STRPTR buffer, long size)
  145. {
  146.   UBYTE *retval = (UBYTE *) NULL;
  147.   char *nlpos;
  148.  
  149.   retval = FGets (file, buffer, size);
  150.  
  151.   if (retval && (nlpos = strchr ((char *) retval, '\n')))
  152.     *nlpos = STRINGEND;
  153.  
  154.   while (retval && strchr (";#\f\t\0", (int) (*retval)))
  155.     {
  156.       retval = FGets (file, buffer, size);
  157.  
  158.       if (retval && (nlpos = strchr ((char *) retval, '\n')))
  159.     *nlpos = STRINGEND;
  160.     }
  161.  
  162.   return retval;
  163. }
  164.  
  165. static int
  166. ReadCompanies (BPTR hfile)
  167. {
  168.   UBYTE *check;
  169.   int count, loop = 0;
  170.  
  171.   check = myFGets (hfile, filebuffer, MAXLINE);
  172.   if (check)
  173.     {
  174.       count = atoi ((char *) check);
  175.  
  176.       if (count == 0)
  177.     return FALSE;
  178.  
  179.       if (company_str = (char **) ALLOCHW (count * sizeof (char *)))
  180.     {
  181.       check = myFGets (hfile, filebuffer, MAXLINE);
  182.  
  183.       while ((loop < count) && check)
  184.         {
  185.           if (*check)
  186.         {
  187.           company_str[loop] = ALLOCHW (strlen ((char *) check) + 1);
  188.  
  189.           if (!company_str[loop])
  190.             return FALSE;
  191.  
  192.           strcpy (company_str[loop++], (char *) check);
  193.         }
  194.  
  195.           if (loop < count)
  196.         check = myFGets (hfile, filebuffer, MAXLINE);
  197.         }
  198.  
  199.       if ((loop < count) || (check == NULL))
  200.         return FALSE;
  201.  
  202.       return TRUE;
  203.     }
  204.     }
  205.  
  206.   return FALSE;
  207. }
  208.  
  209. static STRPTR
  210. CheckHardwareEntry (STRPTR buffer, int *type)
  211. {
  212.   char *eqpos = NULL;
  213.   int i;
  214.  
  215.   *type = END;
  216.  
  217.   if (!strcmp ((char *) buffer, datatype[END]))
  218.     return (STRPTR) eqpos;
  219.  
  220.   *type = UNKNOWN;
  221.  
  222.   for (i = MANU_NR; i < UNKNOWN; i++)
  223.     if (!strncmp ((char *) buffer, datatype[i], strlen (datatype[i])))
  224.       {
  225.     eqpos = strchr ((char *) buffer, '\=');
  226.  
  227.     eqpos++;
  228.  
  229.     while (*eqpos == ' ')
  230.       eqpos++;
  231.  
  232.     *type = i;
  233.  
  234.     return (STRPTR) eqpos;
  235.       }
  236.  
  237.   return (STRPTR) eqpos;
  238. }
  239.  
  240. static int
  241. ReadHardwareData (BPTR hfile)
  242. {
  243.   UBYTE *check, *data;
  244.   int count = 0, loop = 0;
  245.   int type, err;
  246.  
  247.   check = myFGets (hfile, filebuffer, MAXLINE);
  248.   if (check)
  249.     {
  250.       count = atoi ((char *) check);
  251.  
  252.       hardwarecnt = count;
  253.  
  254.       if (count == 0)
  255.     return FALSE;
  256.  
  257.       if (manu = ALLOCHW ((count + 1) * sizeof (MANUFACTURER)))
  258.     {
  259.       err = FALSE;
  260.  
  261.       check = myFGets (hfile, filebuffer, MAXLINE);
  262.  
  263.       while (loop < count && check && !err)
  264.         {
  265.           data = CheckHardwareEntry (check, &type);
  266.  
  267.           switch (type)
  268.         {
  269.         case MANU_NR:
  270.           manu[loop].manu_nr = (WORD) atoi ((char *) data);
  271.           break;
  272.  
  273.         case PROD_NR:
  274.           manu[loop].prod_nr = (WORD) atoi ((char *) data);
  275.           break;
  276.  
  277.         case TYPE_NR:
  278.           manu[loop].type_nr = (WORD) atoi ((char *) data);
  279.           break;
  280.  
  281.         case COMPANY:
  282.           manu[loop].company = atoi ((char *) data);
  283.           break;
  284.  
  285.         case NAME_STR:
  286.           manu[loop].name = ALLOCHW (strlen ((char *) data) + 1);
  287.  
  288.           if (manu[loop].name)
  289.             strcpy (manu[loop].name, (char *) data);
  290.           else
  291.             {
  292.               ErrorHandle ((char *) data, MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  293.               err = TRUE;
  294.             }
  295.           break;
  296.  
  297.         case END:
  298.           loop++;
  299.           break;
  300.  
  301.         default:
  302.           ErrorHandle ((char *) check, DATA_ENTRY_ERR, TYPE_FAIL, NO_KILL);
  303.           break;
  304.         }
  305.  
  306.           if (!err)
  307.         check = myFGets (hfile, filebuffer, MAXLINE);
  308.         }
  309.  
  310.       if (err || loop < count)
  311.         return FALSE;
  312.  
  313.       return TRUE;
  314.     }
  315.       else
  316.     {
  317.       ErrorHandle ((char *) RSysFiles.Hardware, MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  318.       return FALSE;
  319.     }
  320.     }
  321.  
  322.   return FALSE;
  323. }
  324.  
  325. void
  326. BuildHardwareList (void)
  327. {
  328.   int ok;
  329.   BPTR hfile;
  330.  
  331.   DPOS;
  332.   if (!ChooseNewFile ((char *) RSysFiles.Hardware, "Select new Hardware data file..."))
  333.     return;
  334.  
  335.   DPOS;
  336.   if (Flags.dummy1)
  337.     FreeHardwareData ();
  338.  
  339.   DPOS;
  340.   Flags.dummy1 = 0;
  341.  
  342.   DPOS;
  343.   if (!exist ((char *) RSysFiles.Hardware))
  344.     return;
  345.  
  346.   DPOS;
  347.   if (!AllocLineBuffer ())
  348.     return;
  349.  
  350.   DPOS;
  351.   if (hfile = Open (RSysFiles.Hardware, MODE_OLDFILE))
  352.     {
  353.       PrintInfo ("Read hardware datas...", SPEAK, NULL);
  354.  
  355.       DPOS;
  356.       ok = ReadCompanies (hfile);
  357.       if (ok)
  358.     {
  359.       DPOS;
  360.       ok = ReadHardwareData (hfile);
  361.  
  362.       if (ok)
  363.         Flags.dummy1 = 1;
  364.       else
  365.         ErrorHandle ((char *) RSysFiles.Hardware, FILE_ERR, READ_FAIL, NO_KILL);
  366.     }
  367.       else
  368.     ErrorHandle ((char *) RSysFiles.Hardware, FILE_ERR, READ_FAIL, NO_KILL);
  369.  
  370.       DPOS;
  371.       Close (hfile);
  372.  
  373.       DPOS;
  374.       if (Flags.dummy1)
  375.     PrintInfo ("Hardware Datas updated", SPEAK, SEC);
  376.  
  377.     }
  378.   else
  379.     ErrorHandle ((char *) RSysFiles.Hardware, FILE_ERR, OPEN_FAIL, NO_KILL);
  380.  
  381.   DPOS;
  382.   FreeLineBuffer ();
  383.  
  384.   DPOS;
  385.   PrintStatistics ();
  386.  
  387.   return;
  388. }
  389.  
  390. void
  391. FreeLibOffData (void)
  392. {
  393.   FreeRemember (LOKEY, TRUE);
  394.  
  395.   return;
  396. }
  397.  
  398. static STRPTR
  399. CheckLibOffEntry (STRPTR buffer, int *type)
  400. {
  401.   char *eqpos = NULL;
  402.   int i;
  403.  
  404.   *type = LO_END;
  405.  
  406.   if (!strcmp ((char *) buffer, libofftype[LO_END]))
  407.     return (STRPTR) eqpos;
  408.  
  409.   *type = LO_UNKNOWN;
  410.  
  411.   for (i = LO_LIBNAME; i <= LO_FUNCTION; i++)
  412.     if (!strncmp ((char *) buffer, libofftype[i], strlen (libofftype[i])))
  413.       {
  414.     eqpos = strchr ((char *) buffer, '\=');
  415.  
  416.     eqpos++;
  417.  
  418.     while (*eqpos == ' ')
  419.       eqpos++;
  420.  
  421.     *type = i;
  422.  
  423.     return (STRPTR) eqpos;
  424.       }
  425.  
  426.   return (STRPTR) eqpos;
  427. }
  428.  
  429. static int
  430. SplitFunction (char *data, RSYS_FUNCTION * func, RSYS_LIBRARY * lib)
  431. {
  432.   char f[BUFSIZE], b[5], *dptr = data;
  433.   int fc = 0, bc = 0, public, ok = TRUE;
  434.  
  435.   while ((fc < BUFSIZE - 1) && (((f[fc++] = *(dptr++))) != ','));
  436.   f[fc - 1] = STRINGEND;
  437.  
  438.   while ((bc < 5) && ((b[bc++] = (char) (*(dptr++))) != ','));
  439.   b[bc - 1] = STRINGEND;
  440.  
  441.   public = atoi (dptr);
  442.  
  443.   if (!(func->f_name = ALLOCLO (strlen (f) + 1)))
  444.     ok = FALSE;
  445.   else
  446.     {
  447.       strcpy (func->f_name, f);
  448.       func->f_bias = atoi (b);
  449.       func->f_public = (char) ((public == 1) ? 1 : 0);
  450.  
  451.       AddTail (&(lib->l_functions), &(func->f_node));
  452.     }
  453.  
  454.   return ok;
  455. }
  456.  
  457. static int
  458. ReadLibOff (BPTR lofile)
  459. {
  460.   UBYTE *check, *data;
  461.   int ok = TRUE;
  462.   RSYS_FUNCTION *func = NULL;
  463.   RSYS_LIBRARY *lib = NULL;
  464.   int type;
  465.  
  466.   check = myFGets (lofile, filebuffer, MAXLINE);
  467.   while (check && ok != FALSE)
  468.     {
  469.       data = CheckLibOffEntry (check, &type);
  470.  
  471.       switch (type)
  472.     {
  473.     case LO_END:
  474.       AddTail (&Libraries, &(lib->l_node));
  475.       break;
  476.  
  477.     case LO_LIBNAME:
  478.       lib = ALLOCLO (sizeof (RSYS_LIBRARY));
  479.  
  480.       if (!lib)
  481.         ok = FALSE;
  482.       else
  483.         {
  484.           NewList (&(lib->l_functions));
  485.  
  486.           lib->l_name = ALLOCLO (strlen ((char *) data) + 1);
  487.  
  488.           if (!lib->l_name)
  489.         ok = FALSE;
  490.           else
  491.         {
  492.           strcpy ((char *) lib->l_name, (char *) data);
  493.           lib->l_node.ln_Name = (char *) lib->l_name;
  494.         }
  495.         }
  496.       break;
  497.  
  498.     case LO_TYP:
  499.       lib->l_typ = (*data == 'L') ? 1 : 0;
  500.       break;
  501.  
  502.     case LO_BASE:
  503.       lib->l_base = ALLOCLO (strlen ((char *) data) + 1);
  504.  
  505.       if (!lib->l_base)
  506.         ok = FALSE;
  507.       else
  508.         strcpy (lib->l_base, (char *) data);
  509.       break;
  510.  
  511.     case LO_FUNCTION:
  512.       func = ALLOCLO (sizeof (RSYS_LIBRARY));
  513.  
  514.       if (func)
  515.         ok = SplitFunction ((char *) data, func, lib);
  516.       else
  517.         ok = FALSE;
  518.       break;
  519.  
  520.     default:
  521.       ErrorHandle ((char *) check, DATA_ENTRY_ERR, TYPE_FAIL, NO_KILL);
  522.       break;
  523.     }
  524.  
  525.       if (ok == TRUE)
  526.     check = myFGets (lofile, filebuffer, MAXLINE);
  527.       else
  528.     ErrorHandle ((char *) RSysFiles.LibOffsets, FILE_ERR, READ_FAIL, NO_KILL);
  529.     }
  530.  
  531.   return ok;
  532. }
  533.  
  534. void
  535. BuildLibOffsetList (void)
  536. {
  537.   int ok;
  538.   BPTR lofile;
  539.  
  540.   if (!ChooseNewFile ((char *) RSysFiles.LibOffsets, "Select new Library offsets file..."))
  541.     return;
  542.  
  543.   if (Flags.dummy2)
  544.     FreeLibOffData ();
  545.  
  546.   NewList (&Libraries);
  547.  
  548.   Flags.dummy2 = 0;
  549.  
  550.   if (!exist ((char *) RSysFiles.LibOffsets))
  551.     return;
  552.  
  553.   if (!AllocLineBuffer ())
  554.     return;
  555.  
  556.   if (lofile = Open (RSysFiles.LibOffsets, MODE_OLDFILE))
  557.     {
  558.       PrintInfo ("Read library offsets...", SPEAK, NULL);
  559.  
  560.       ok = ReadLibOff (lofile);
  561.       if (ok == TRUE)
  562.     {
  563.       Flags.dummy2 = 1;
  564.       PrintInfo ("Library offsets updated", SPEAK, SEC);
  565.     }
  566.       else
  567.     ErrorHandle ((char *) RSysFiles.LibOffsets, FILE_ERR, READ_FAIL, NO_KILL);
  568.  
  569.       Close (lofile);
  570.     }
  571.   else
  572.     ErrorHandle ((char *) RSysFiles.LibOffsets, FILE_ERR, OPEN_FAIL, NO_KILL);
  573.  
  574.   FreeLineBuffer ();
  575.  
  576.   PrintStatistics ();
  577.  
  578.   return;
  579. }
  580.  
  581. void
  582. FreeAmigaGuideContextMemory (void)
  583. {
  584.   FreeRemember ((REMEMBER **) & ContextKey, TRUE);
  585.  
  586.   return;
  587. }
  588.  
  589. static int
  590. ReadContextFile (UBYTE * filename)
  591. {
  592.   BPTR file;
  593.   UBYTE *check;
  594.   int i = 0, noerror = TRUE, retval = TRUE;
  595.  
  596.   if (exist ((char *) filename))
  597.     {
  598.       if (file = Open (filename, MODE_OLDFILE))
  599.     {
  600.       check = myFGets (file, filebuffer, MAXLINE);
  601.  
  602.       while ((i < MAXENTRY) && check && noerror)
  603.         {
  604.           if (context[i] = AllocRemember ((REMEMBER **) & ContextKey,
  605.                           strlen ((char *) check) + 1,
  606.                           MEMF_CLEAR | MEMF_PUBLIC))
  607.         {
  608.           strcpy ((char *) (context[i++]), (char *) check);
  609.  
  610.           check = myFGets (file, filebuffer, MAXLINE);
  611.         }
  612.           else
  613.         noerror = FALSE;
  614.         }
  615.  
  616.       Close (file);
  617.  
  618.       if (!noerror)
  619.         {
  620.           ErrorHandle ("AGuide nodes", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  621.           retval = FALSE;
  622.         }
  623.  
  624.       if (!check && (i < MAXENTRY))
  625.         {
  626.           ErrorHandle ((char *) filename, DATA_ENTRY_ERR, SIZE_FAIL, NO_KILL);
  627.           retval = FALSE;
  628.         }
  629.  
  630.       context[MAXENTRY] = (UBYTE *) NULL;
  631.  
  632.       return retval;
  633.     }
  634.       else
  635.     ErrorHandle ((char *) filename, FILE_ERR, OPEN_FAIL, NO_KILL);
  636.     }
  637.  
  638.   return FALSE;
  639. }
  640.  
  641. void
  642. BuildHelpList (void)
  643. {
  644.   if (Flags.helpmode)
  645.     return;
  646.  
  647.   if (!ChooseNewFile ((char *) RSysFiles.Guide, "Select AGuide documentation...") ||
  648.       !ChooseNewFile ((char *) RSysFiles.GuideContext, "Select new Context nodes file..."))
  649.     return;
  650.  
  651.   if (Flags.dummy3)
  652.     FreeAmigaGuideContextMemory ();
  653.  
  654.   Flags.dummy3 = 0;
  655.  
  656.   if (!AllocLineBuffer ())
  657.     return;
  658.  
  659.   PrintInfo ("Read context nodes...", SPEAK, NULL);
  660.  
  661.   if (!exist ((char *) RSysFiles.GuideContext) || !ReadContextFile (RSysFiles.GuideContext))
  662.     {
  663.       if (SysWnd)
  664.     OffMenu (SysWnd, FULLMENUNUM (0, 1, 0));
  665.  
  666.       Flags.nohelp = 1;
  667.     }
  668.   else
  669.     {
  670.       if (SysWnd)
  671.     OnMenu (SysWnd, FULLMENUNUM (0, 1, 0));
  672.       Flags.dummy3 = 1;
  673.  
  674.       PrintInfo ("Context nodes updated", SPEAK, SEC);
  675.     }
  676.  
  677.   FreeLineBuffer ();
  678.  
  679.   PrintStatistics ();
  680.  
  681.   return;
  682. }
  683.  
  684. void
  685. SaveConfig (void)
  686. {
  687.   DISKOBJECT *dop;
  688.   char **NewToolTypes, **OldToolTypes;
  689.   char *ToolTypes[] =
  690.   {
  691.   /* 00 */ "DONOTWAIT",
  692.  
  693.   /* 01 */ "CX_HOTKEY=",
  694.   /* 02 */ "CX_CRYPT=",
  695.   /* 03 */ "CX_FINDFILE=",
  696.   /* 04 */ "CX_FORMAT=",
  697.   /* 05 */ "CX_HUNKLIST=",
  698.   /* 06 */ "CX_CRC=",
  699.   /* 07 */ "CX_SAVEWINDOW=",
  700.   /* 08 */ "CX_FILEREQUEST=",
  701.  
  702.   /* 09 */ "NOFASTMODE",
  703.   /* 10 */ "NOSORT",
  704.   /* 11 */ "WORKINGBAR",
  705.   /* 12 */ "AUTOFRONT",
  706.   /* 13 */ "MOUSEWINDOW",
  707.   /* 14 */ "TOPAZFONT",
  708.   /* 15 */ "NOSAVEASKING",
  709.   /* 16 */ "NOAPPICON",
  710.  
  711.   /* 17 */ "BACKPATTERNCOL=",
  712.   /* 18 */ "BACKGROUNDCOL=",
  713.   /* 19 */ "BACKPATTERN=",
  714.   /* 20 */ "DETAILPEN=",
  715.   /* 21 */ "BLOCKPEN=",
  716.   /* 22 */ "MENUPEN=",
  717.  
  718.   /* 23 */ "HARDWAREDATA=",
  719.   /* 24 */ "LIBOFFDATA=",
  720.   /* 25 */ "AGUIDEDOC=",
  721.   /* 26 */ "AGUIDECONTEXT=",
  722.   /* 27 */ "ACTIONFILE=",
  723.   /* 28 */ "OUTWINDOW=",
  724.   /* 29 */ "LISTHEIGHT=",
  725.  
  726.   /* 30 */ "TEXTFORMATTER",
  727.   /* 31 */ "ICONX=",
  728.   /* 32 */ "ICONY=",
  729.   /* 33 */ NULL,
  730.   };
  731.   int i;
  732.   REMEMBER *ToolTypeKey = NULL;
  733.  
  734.   if (dop = GetProgramIcon ())
  735.     {
  736.       PrintInfo ("Write Info file...", SPEAK, NULL);
  737.  
  738.       NewToolTypes = (char **) AllocRemember (&ToolTypeKey, 35 * sizeof (char *), MEMF_CLEAR | MEMF_PUBLIC);
  739.  
  740.       if (NewToolTypes)
  741.     {
  742.       for (i = 0; i < 33; i++)
  743.         {
  744.           NewToolTypes[i] = AllocRemember (&ToolTypeKey, 60, MEMF_CLEAR | MEMF_PUBLIC);
  745.           if (!NewToolTypes[i])
  746.         {
  747.           FreeDiskObject (dop);
  748.           FreeRemember (&ToolTypeKey, TRUE);
  749.           ErrorHandle ("AllocRemember()", MEMORY_ERR, ALLOC_FAIL, KILL);
  750.         }
  751.         }
  752.  
  753.       strcpy (NewToolTypes[0], ToolTypes[0]);
  754.  
  755.       for (i = 1; i < 9; i++)
  756.         sprintf (NewToolTypes[i], "%s%s", ToolTypes[i], hotkey[i - 1]);
  757.  
  758. #define NEXT 9
  759.  
  760.       if (!Flags.fastmode)
  761.         strcpy (NewToolTypes[NEXT + 0], ToolTypes[NEXT + 0]);
  762.       else
  763.         sprintf (NewToolTypes[NEXT + 0], "(%s)", ToolTypes[NEXT + 0]);
  764.  
  765.       if (!Flags.sortmode)
  766.         strcpy (NewToolTypes[NEXT + 1], ToolTypes[NEXT + 1]);
  767.       else
  768.         sprintf (NewToolTypes[NEXT + 1], "(%s)", ToolTypes[NEXT + 1]);
  769.  
  770.       if (Flags.workingbar)
  771.         strcpy (NewToolTypes[NEXT + 2], ToolTypes[NEXT + 2]);
  772.       else
  773.         sprintf (NewToolTypes[NEXT + 2], "(%s)", ToolTypes[NEXT + 2]);
  774.  
  775.       if (Flags.autofront)
  776.         strcpy (NewToolTypes[NEXT + 3], ToolTypes[NEXT + 3]);
  777.       else
  778.         sprintf (NewToolTypes[NEXT + 3], "(%s)", ToolTypes[NEXT + 3]);
  779.  
  780.       if (Flags.mousewindow)
  781.         strcpy (NewToolTypes[NEXT + 4], ToolTypes[NEXT + 4]);
  782.       else
  783.         sprintf (NewToolTypes[NEXT + 4], "(%s)", ToolTypes[NEXT + 4]);
  784.  
  785.       if (Flags.sysfont)
  786.         strcpy (NewToolTypes[NEXT + 5], ToolTypes[NEXT + 5]);
  787.       else
  788.         sprintf (NewToolTypes[NEXT + 5], "(%s)", ToolTypes[NEXT + 5]);
  789.  
  790.       if (!Flags.saveasking)
  791.         strcpy (NewToolTypes[NEXT + 6], ToolTypes[NEXT + 6]);
  792.       else
  793.         sprintf (NewToolTypes[NEXT + 6], "(%s)", ToolTypes[NEXT + 6]);
  794.  
  795.       if (!Flags.appicon)
  796.         strcpy (NewToolTypes[NEXT + 7], ToolTypes[NEXT + 7]);
  797.       else
  798.         sprintf (NewToolTypes[NEXT + 7], "(%s)", ToolTypes[NEXT + 7]);
  799.  
  800.       if (bpc)
  801.         sprintf (NewToolTypes[NEXT + 8], "%s%ld", ToolTypes[NEXT + 8], bpc);
  802.       else
  803.         sprintf (NewToolTypes[NEXT + 8], "(%s)", ToolTypes[NEXT + 8]);
  804.  
  805.       if (bgc)
  806.         sprintf (NewToolTypes[NEXT + 9], "%s%ld", ToolTypes[NEXT + 9], bgc);
  807.       else
  808.         sprintf (NewToolTypes[NEXT + 9], "(%s)", ToolTypes[NEXT + 9]);
  809.  
  810.       if (bpp)
  811.         sprintf (NewToolTypes[NEXT + 10], "%s%08lX", ToolTypes[NEXT + 10], bpp);
  812.       else
  813.         sprintf (NewToolTypes[NEXT + 10], "(%s)", ToolTypes[NEXT + 10]);
  814.  
  815.       if (winddetail)
  816.         sprintf (NewToolTypes[NEXT + 11], "%s%ld", ToolTypes[NEXT + 11], winddetail);
  817.       else
  818.         sprintf (NewToolTypes[NEXT + 11], "(%s)", ToolTypes[NEXT + 11]);
  819.  
  820.       if (windblock)
  821.         sprintf (NewToolTypes[NEXT + 12], "%s%ld", ToolTypes[NEXT + 12], windblock);
  822.       else
  823.         sprintf (NewToolTypes[NEXT + 12], "(%s)", ToolTypes[NEXT + 12]);
  824.  
  825.       if (menudetail)
  826.         sprintf (NewToolTypes[NEXT + 13], "%s%ld", ToolTypes[NEXT + 13], menudetail);
  827.       else
  828.         sprintf (NewToolTypes[NEXT + 13], "(%s)", ToolTypes[NEXT + 13]);
  829.  
  830.       sprintf (NewToolTypes[NEXT + 14], "%s%s", ToolTypes[NEXT + 14], RSysFiles.Hardware);
  831.       sprintf (NewToolTypes[NEXT + 15], "%s%s", ToolTypes[NEXT + 15], RSysFiles.LibOffsets);
  832.       sprintf (NewToolTypes[NEXT + 16], "%s%s", ToolTypes[NEXT + 16], RSysFiles.Guide);
  833.       sprintf (NewToolTypes[NEXT + 17], "%s%s", ToolTypes[NEXT + 17], RSysFiles.GuideContext);
  834.       sprintf (NewToolTypes[NEXT + 18], "%s%s", ToolTypes[NEXT + 18], RSysFiles.ActionFile);
  835.       sprintf (NewToolTypes[NEXT + 19], "%s%s", ToolTypes[NEXT + 19], autocon);
  836.  
  837.       sprintf (NewToolTypes[NEXT + 20], "%s%ld", ToolTypes[NEXT + 20], newlvh);
  838.  
  839.       if (!Flags.textformat)
  840.         strcpy (NewToolTypes[NEXT + 21], ToolTypes[NEXT + 21]);
  841.       else
  842.         sprintf (NewToolTypes[NEXT + 21], "(%s)", ToolTypes[NEXT + 21]);
  843.  
  844.       if (iconx != NO_ICON_POSITION)
  845.         sprintf (NewToolTypes[NEXT + 22], "%s%ld", ToolTypes[NEXT + 22], iconx);
  846.       else
  847.         sprintf (NewToolTypes[NEXT + 22], "(%s)", ToolTypes[NEXT + 22]);
  848.  
  849.       if (icony != NO_ICON_POSITION)
  850.         sprintf (NewToolTypes[NEXT + 23], "%s%ld", ToolTypes[NEXT + 23], icony);
  851.       else
  852.         sprintf (NewToolTypes[NEXT + 23], "(%s)", ToolTypes[NEXT + 23]);
  853.  
  854.       NewToolTypes[NEXT + 24] = NULL;
  855.  
  856.       OldToolTypes = dop->do_ToolTypes;
  857.  
  858.       dop->do_ToolTypes = NewToolTypes;
  859.  
  860.       if (!PutDiskObject ((STRPTR) RSysName, dop))
  861.         ErrorHandle (RSysName, FILE_ERR, WRITE_FAIL, NO_KILL);
  862.       else
  863.         {
  864.           dop->do_ToolTypes = OldToolTypes;
  865.  
  866.           FreeRemember (&ToolTypeKey, TRUE);
  867.  
  868.           PrintInfo ("Info file written...", SPEAK, SEC);
  869.         }
  870.     }
  871.       else
  872.     {
  873.       FreeDiskObject (dop);
  874.       FreeRemember (&ToolTypeKey, TRUE);
  875.       ErrorHandle ("AllocRemember()", MEMORY_ERR, ALLOC_FAIL, KILL);
  876.     }
  877.  
  878.       FreeDiskObject (dop);
  879.     }
  880.  
  881.   PrintStatistics ();
  882.  
  883.   return;
  884. }
  885.  
  886. void
  887. FreeValidAddressList (void)
  888. {
  889.   FreeRemember (VMKEY, TRUE);
  890.   return;
  891. }
  892.  
  893. RSYS_ValidMemoryNode *
  894. CheckNode (ULONG memoryptr)
  895. {
  896.   NODE *node;
  897.   RSYS_ValidMemoryNode *vmnode;
  898.  
  899.   for (node = ValidMemoryList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  900.     {
  901.       vmnode = (RSYS_ValidMemoryNode *) node;
  902.       if (vmnode->vm_startaddress <= memoryptr && memoryptr <= vmnode->vm_endaddress)
  903.     return vmnode;
  904.     }
  905.  
  906.   return NULL;
  907. }
  908.  
  909. static int
  910. MarkAddress (ULONG start, ULONG length, char type, char *comment)
  911. {
  912.   RSYS_ValidMemoryNode *VMNode;
  913.  
  914.   if (VMNode = ALLOCVM (sizeof (RSYS_ValidMemoryNode)))
  915.     {
  916.       VMNode->vm_node.ln_Type = NT_USER;
  917.       VMNode->vm_node.ln_Pri = 0;
  918.  
  919.       VMNode->vm_startaddress = start;
  920.       VMNode->vm_endaddress = start + length;
  921.       VMNode->vm_type = type;
  922.  
  923.       strncpy (VMNode->vm_comment, comment, BUFSIZE);
  924.  
  925.       AddTail (&ValidMemoryList, &(VMNode->vm_node));
  926.  
  927.       return TRUE;
  928.     }
  929.   else
  930.     ErrorHandle ("RSYS_ValidMemoryNode", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  931.  
  932.   return FALSE;
  933. }
  934.  
  935. void
  936. BuildValidAddressList (void)
  937. {
  938.   MEMHEADER *mem;
  939.   int ok;
  940.  
  941.   NewList (&ValidMemoryList);
  942.  
  943.   /*
  944.    * Special case the first page of CHIP RAM
  945.    */
  946.   ok = MarkAddress (0, 0x1000, (char) NULL, "First page CHIP-RAM");
  947.  
  948.   /*
  949.    * Map in the free memory
  950.    */
  951.   Forbid ();
  952.  
  953.   mem = (MEMHEADER *) SysBase->MemList.lh_Head;
  954.   while (mem->mh_Node.ln_Succ && ok)
  955.     {
  956.       ok = MarkAddress ((ULONG) (mem->mh_Lower),
  957.             (ULONG) (mem->mh_Upper) - (ULONG) (mem->mh_Lower),
  958.             ((MEMF_CHIP & TypeOfMem (mem->mh_Lower)) ?
  959.              (char) (VALID) : (char) (CACHEABLE | VALID)),
  960.             "Memory list entry");
  961.  
  962.       mem = ok ? (MEMHEADER *) (mem->mh_Node.ln_Succ) : NULL;
  963.     }
  964.  
  965.   Permit ();
  966.  
  967.   /*
  968.    * Map in the autoconfig boards
  969.    */
  970.   if (ok && (ExpansionBase = (EXPANSIONBASE *) OpenLibrary ((STRPTR) "expansion.library", 0)))
  971.     {
  972.       CONFIGDEV *cd = NULL;
  973.  
  974.       while ((cd = FindConfigDev (cd, (long) (-1L), (long) (-1L))) != NULL && ok)
  975.     {
  976.       /* Skip memory boards... */
  977.       if (!(cd->cd_Rom.er_Type & ERTF_MEMLIST))
  978.         ok = MarkAddress ((ULONG) (cd->cd_BoardAddr),
  979.                   cd->cd_BoardSize,
  980.                   (char) VALID, "Expansion memory");
  981.     }
  982.       CloseLibrary ((LIBRARY *) ExpansionBase);
  983.     }
  984.  
  985.   /*
  986.    * Now for the control areas...
  987.    */
  988.   if (ok)
  989.     ok = MarkAddress (0x00BC0000, 0x00040000, (char) VALID, "Control area 1");
  990.   if (ok)
  991.     ok = MarkAddress (0x00D80000, 0x00080000, (char) VALID, "Control area 2");
  992.  
  993.   /*
  994.    * and the ROM...
  995.    */
  996.   if (ok)
  997.     ok = MarkAddress (0x00F80000, 0x00080000,
  998.               (char) (CACHEABLE | WRITEPROTECT), "ROM-address");
  999.  
  1000.   /*
  1001.    * If the credit card resource, make the addresses valid...
  1002.    */
  1003.   if (ok && OpenResource ((STRPTR) "card.resource"))
  1004.     ok = MarkAddress (0x00600000, 0x00440002, (char) VALID, "Card resource range");
  1005.  
  1006.   /*
  1007.    * If CD-based Amiga (CDTV, A570, etc.)
  1008.    */
  1009.   if (ok && FindResident ((STRPTR) "cdstrap"))
  1010.     {
  1011.       ok = MarkAddress (0x00E00000, 0x00080000, (char) VALID, "CDTV-RAM");
  1012.       if (ok)
  1013.     ok = MarkAddress (0x00B80000, 0x00040000, (char) VALID, "CDTV-RAM");
  1014.     }
  1015.  
  1016.   /*
  1017.    * Check for ReKick/ZKick/KickIt
  1018.    */
  1019.   if (ok && ((((ULONG) (SysBase->LibNode.lib_Node.ln_Name)) >> 16) == 0x20))
  1020.     ok = MarkAddress ((ULONG) 0x00200000, (ULONG) 0x00080000,
  1021.               (char) (VALID | CACHEABLE | WRITEPROTECT),
  1022.               "KickMem-range for ZKick");
  1023.  
  1024.   Flags.dummy4 = (ok ? 1 : 0);
  1025.  
  1026.   return;
  1027. }
  1028.  
  1029. void
  1030. BuildAllDataEntries (void)
  1031. {
  1032.   BuildActionList ();
  1033.   BuildHelpList ();
  1034.   BuildHardwareList ();
  1035.   BuildLibOffsetList ();
  1036.  
  1037.   return;
  1038. }
  1039.